#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <unistd.h>
#include <thread>
#include <pthread.h>

//线程的局部存储
__thread int num = 0;

void *start(void *args)
{
    while(true)
    {
        std::cout << "new thread" << std::endl;
        sleep(1);
    }

    return 0;
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, start, (void *)"thread-1");

    sleep(3);
    pthread_cancel(tid);
    std::cout << "取消线程" << tid << std::endl;
    sleep(3);

    void *ret = nullptr;
    pthread_join(tid, &ret);
    std::cout << "new thread exit code: " << (long long)ret << std::endl;

    return 0;
}

////////////////////////////////////////////

//pthread_exit
// void *start(void *args)
// {
//     sleep(2);

//     pthread_exit((void *)10);
// }

// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, start, (void *)"thread-1");

//     void *ret = nullptr;
//     pthread_join(tid, &ret);
//     std::cout << "new thread exit code: " << (long long)ret << std::endl;

//     return 0;
// }

///////////////////////////////////////////////////////////

// int *addr = nullptr;

// void *start1(void *args)
// {
//     std::string name = static_cast<const char *>(args);
//     int a = 100;
//     addr = &a;
//     while(true)
//     {
//         std::cout << name << " local val a: " << a <<std::endl;
//         sleep(1);
//     }
// }

// void *start2(void *args)
// {
//     std::string name = static_cast<const char *>(args);
//     while(true)
//     {
//         if(addr != nullptr)
//             std::cout << name << " local val a: " << (*addr)++ <<std::endl;
//         sleep(1);
//     }
// }

// int main()
// {
//     pthread_t tid1,tid2;
//     pthread_create(&tid1, nullptr, start1, (void*)"thread-1");
//     pthread_create(&tid2, nullptr, start2, (void*)"thread-2");
    
//     pthread_join(tid1,nullptr);
//     pthread_join(tid2,nullptr);

//     return 0;
// }

////////////////////////////////////////////////////////////

// class ThreadData
// {
// public:
//     ThreadData()
//     {}
//     void Init(const std::string &name, int a, int b)
//     {
//         _name = name;
//         _a = a;
//         _b = b;
//     }
//     void Excute()
//     {
//         _result = _a + _b;
//     }
//     int Result(){ return _result; }
//     std::string Name(){ return _name; }
//     void SetId(pthread_t tid) { _tid = tid;}
//     pthread_t Id() { return _tid; }
//     int A(){return _a;}
//     int B(){return _b;}
//     ~ThreadData()
//     {}
// private:
//     std::string _name;
//     int _a;
//     int _b;
//     int _result;
//     pthread_t _tid;
// };

// // 被重入了！！
// void *routine(void *args)
// {
//     ThreadData *td = static_cast<ThreadData *>(args);
//     while (true)
//     {
//         td->Excute();
//         sleep(1);
//         break;
//     }

//     return td;
// }

// #define NUM 10

// int main()
// {
//     ThreadData td[NUM];
//     // 准备我们要加工处理的数据
//     for(int i = 0; i < NUM; i++)
//     {
//         char id[64];
//         snprintf(id, sizeof(id), "thread-%d", i);
//         td[i].Init(id, i*10, i*20);
//     }

//     // 创建多线程
//     for(int i = 0; i < NUM; i++)
//     {
//         pthread_t id;
//         pthread_create(&id, nullptr, routine, &td[i]);
//         td[i].SetId(id);
//     }

//     // 等待多个线程
//     for(int i =0; i< NUM;i++)
//     {
//         pthread_join(td[i].Id(), nullptr);
//     }

//     // 汇总处理结果
//     for(int i =0;i < NUM; i++)
//     {
//         printf("td[%d]: %d+%d=%d[%ld]\n", i, td[i].A(), td[i].B(), td[i].Result(), td[i].Id());
//     }

//     return 0;
// }


///////////////////////////////////////////////////////

// std::string toHex(pthread_t tid)
// {
//     char buffer[64];
//     snprintf(buffer, sizeof(buffer), "0x%lx", tid);
//     return buffer;
// }

// void *routine1(void *args)
// {
//     std::string name = static_cast<const char *>(args);
//     while(true)
//     {
//         std::cout << "我是新线程，我的名字是：" << name << ", my tid is: " << toHex(pthread_self()) << std::endl;
//         sleep(1);
//         break;
//     }

//     return (void*)10;
// }


// int main()
// {
//     pthread_t tid1;
//     pthread_create(&tid1, nullptr, routine1, (void*)"thread-1");

//     //阻塞式等待
//     void *ret = nullptr;
//     int n = pthread_join(tid1, &ret);
//     if(n != 0)
//     {
//         std::cerr << "join error: " << n << ", " << strerror(n) << std::endl;
//         return 1;
//     }
//     std::cout << "join success ret: " << (long long)ret << std::endl;

//     return 0;
// }

/////////////////////////////////////////////////////////

// class ThreadData
// {
// public:
//     ThreadData(const std::string &name, int a, int b)
//     {
//         _name = name;
//         _a = a;
//         _b = b;
//     }
//     std::string Name(){ return _name; }
//     int A(){return _a;}
//     int B(){return _b;}
//     ~ThreadData()
//     {}
// private:
//     std::string _name;
//     int _a;
//     int _b;
// };

// int gval = 100;

// std::string toHex(pthread_t tid)
// {
//     char buffer[64];
//     snprintf(buffer, sizeof(buffer), "0x%lx", tid);
//     return buffer;
// }

// //多个线程都执行该方法时，该方法被重入了
// void *routine1(void *args)
// {
//     std::string name = static_cast<const char *>(args);
//     while(true)
//     {
//         std::cout << "我是新线程，我的名字是：" << name << ", my tid is: " << toHex(pthread_self()) << "全局变量（修改）" << gval << std::endl;
//         gval++;
//         sleep(1);
//         break;
//     }
//     // return 0;
//     return (void*)10;
// }

// void *routine2(void *args)
// {
//     std::string name = static_cast<const char *>(args);
//     while(true)
//     {
//         std::cout << "我是新线程，我的名字是：" << name << ", my tid is: " << toHex(pthread_self()) << "全局变量（只读）" << gval  << std::endl;
//         sleep(1);
//     }
//     return 0;
// }

// int main()
// {
//     //新线程和main线程谁先运行，不确定
//     // pthread_t tid1;
//     // pthread_create(&tid1, nullptr, routine1, (void*)"thread-1");

//     //传参问题
//     pthread_t tid1;
//     ThreadData *td = new ThreadData("thread-1", 10, 20);
//     pthread_create(&tid1, nullptr, routine1, td);

//     //阻塞式等待
//     int n = pthread_join(tid1, nullptr);
//     if(n != 0)
//     {
//         std::cerr << "join error: " << n << ", " << strerror(n) << std::endl;
//         return 1;
//     }
//     std::cout << "join success"<< std::endl;

//     // pthread_t tid2;
//     // pthread_create(&tid2, nullptr, routine2, (void*)"thread-2");

//     // pthread_t tid3;
//     // pthread_create(&tid3, nullptr, routine, (void*)"thread-3");

//     printf("new thread id: 0x%lx\n", tid1);
//     // printf("new thread id: 0x%lx\n", tid2);
//     // printf("new thread id: 0x%lx\n", tid3);

//     while(true)
//     {
//         std::cout << "我是main线程" << std::endl;
//         sleep(1);
//     }

//     return 0;
// }

////////////////////////////////////////////////////////////////////////

// void *routine(void *args)
// {
//     std::string name = static_cast<const char *>(args);
//     while (true)
//     {
//         std::cout << "我是新线程,我的名字是: " << name << std::endl;
//         sleep(1);
//     }
//     return 0;
// }

// int main()
// {
//     std::thread t([](){
//         while (true)
//         {
//             std::cout << "我是新线程,我的名字是 : new thread "  << std::endl;
//             sleep(1);
//         }
//     });

//     while (true)
//     {
//         std::cout << "我是main线程..."  << std::endl;
//         sleep(1);
//     }

//     // pthread_t tid;
//     // int n = pthread_create(&tid, nullptr, routine, (void *)"thread-1");
//     // if (n != 0)
//     // {
//     //     std::cout << "create thread error: " << strerror(n) << std::endl;
//     //     return 1;
//     // }
//     // while (true)
//     // {
//     //     std::cout << "我是main线程..."  << std::endl;
//     //     sleep(1);
//     // }
// }
